package com.example.ross.service.impl;

import com.baomidou.mybatisplus.core.conditions.AbstractWrapper;
import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;

import com.example.ross.entity.User;
import com.example.ross.mapper.UserMapper;
import com.example.ross.model.ResultFormat;
import com.example.ross.service.UserService;
import com.example.ross.utils.RedisUtil;
import com.example.ross.utils.ResultUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.apache.commons.lang3.StringUtils;

import java.util.Collection;
import java.util.List;
import java.util.Map;

/**
 * User 接口实现类
 * @author RossZhang
 */
@Service
@Transactional
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService {

    private Logger logger = LoggerFactory.getLogger(UserService.class);

    @Autowired
    private UserMapper userMapper;

    @Autowired
    private RedisUtil redisUtil;

    /**
     * 分页查询用户信息
     * @param user
     * @param page
     * @param limit
     * @return
     */
    @Override
    public IPage<User> selectUserList(User user, Integer page, Integer limit) {
        AbstractWrapper wrapper = new QueryWrapper<User>();
        if (user != null){
            if (! StringUtils.isEmpty(user.getUserName())){
                wrapper.like("user_name",user.getUserName());
            }
        }
        //查询状态为0 的数据
        /*wrapper.eq("state", 0);*/
        /**
         * 对查询数据进行排序(根据注册时间进行排序)
         * orderByAsc:升序
         * orderByDesc:降序
         */
        //查询状态为0 的数据
        wrapper.orderByAsc("register_time");
        Page<User> iPage = new Page<User>(page,limit);
        IPage<User> pgLinksPage = userMapper.selectPage(iPage,wrapper);
        return pgLinksPage;
    }

    /**
     * 添加
     * @param user
     * @return
     */
    @Override
    public ResultFormat saveUser(User user) {
        logger.info("-----------------进入service实现层 添加用户信息-----------------");
        /**
         * 查询用户名称是否存在
         * 如果存在那就返回提示已经存在
         * 如果不存在就执行添加
         */
        AbstractWrapper wrapper = new QueryWrapper();
        wrapper.eq("user_name",user.getUserName());
        User userWrapperGet = userMapper.selectOne(wrapper);
        logger.info("pgLabelsWrapperGet={}", userWrapperGet);

        if (userWrapperGet != null){
            return ResultUtil.error(101,"用户名称已存在!");
        }
        user.setState(0);

        Integer insert = userMapper.insert(user);

        if (insert > 0){
            redisUtil.lSet("userId",user.getUserId());
            redisUtil.set("user"+user.getUserId(),user);
        }

        return ResultUtil.success();
    }

    /**
     * 修改
     * @param user
     * @return
     */
    @Override
    public Integer updateUser(User user) {
        logger.info("-----------------进入service实现层 修改用户信息-----------------");
        /**
         * 查询标签名称是否存在
         * 如果存在那就返回提示已经存在
         * 如果不存在那就修改
         */
        if (user != null){
            if (user.getUserId() != null && !user.getUserName().isEmpty()){
                User pgLabelsByIdInfo = userMapper.selectById(user.getUserId());
                AbstractWrapper wrapper = new QueryWrapper();
                wrapper.eq("user_name",user.getUserName());
                User pgLabelsByNameInfo = userMapper.selectOne(wrapper);

                /**
                 * 如果通过id查询的用户信息与前台传过来的名称一致
                 * 可修改其它数据
                 */
                if (pgLabelsByIdInfo != null){
                    logger.info("pgLabelsByIdInfo={}", pgLabelsByIdInfo);
                    if (pgLabelsByIdInfo.getUserName().equals(user.getUserName())){
                        Integer updateById = userMapper.updateById(user);
                        if (updateById > 0){
                            redisUtil.set("user"+ user.getUserId(),user);
                            return 200;
                        }
                    }
                }

                /**
                 * 从前台传过来的用户名称与id查询的名称不一致
                 * 再通过名称查询的数据为空就可以修改
                 */
                if (pgLabelsByNameInfo != null){
                    logger.info("pgLabelsByNameInfo={}", pgLabelsByNameInfo);
                    if (!pgLabelsByNameInfo.getUserName().equals(pgLabelsByIdInfo.getUserName())){
                        return 101;
                    }
                }
            }
        }
        /**
         * 如果用户名名称不一致就修改成 不存在的用户名称
         */
        Integer updateById = userMapper.updateById(user);
        if (updateById > 0) {
            redisUtil.set("label:" + user.getUserName(), user);
            return 200;
        }
        return 100;
    }

    /**
     * 删除
     * @param userId
     * @return
     */
    @Override
    public Boolean deleteUserId(Integer userId) {
        logger.info("-----------------进入service实现层 删除用户信息-----------------");
        Integer deleteById = userMapper.deleteById(userId);

        if (deleteById > 0){
            Long delete = redisUtil.delete("user:"+String.valueOf(userId));
        }
        return deleteById==0?true:false;
    }

    @Override
    public boolean saveBatch(Collection collection, int i) {
        return false;
    }

    @Override
    public boolean saveOrUpdateBatch(Collection collection, int i) {
        return false;
    }

    @Override
    public boolean remove(Wrapper wrapper) {
        return false;
    }

    @Override
    public Map<String, Object> getMap(Wrapper wrapper) {
        return null;
    }

    @Override
    public int count(Wrapper wrapper) {
        return 0;
    }

    @Override
    public List list(Wrapper wrapper) {
        return null;
    }

    @Override
    public IPage page(IPage iPage, Wrapper wrapper) {
        return null;
    }

    @Override
    public List<Map<String, Object>> listMaps(Wrapper wrapper) {
        return null;
    }

    @Override
    public List<Object> listObjs(Wrapper wrapper) {
        return null;
    }

    @Override
    public IPage<Map<String, Object>> pageMaps(IPage iPage, Wrapper wrapper) {
        return null;
    }
}
